// 《围棋》作者版权所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 开始：构建！amd64&！ppc64&！ppc64le&！arm64 

package cipher

import (
	"runtime"
	"unsafe"
)

// xorBytes XOR a和b中的字节。目标应该有足够的
// 空间，否则xorBytes会死机。返回异或的字节数。
func xorBytes(dst, a, b []byte) int {
	n := len(a)
	if len(b) < n {
		n = len(b)
	}
	if n == 0 {
		return 0
	}

	switch {
	case supportsUnaligned:
		fastXORBytes(dst, a, b, n)
	default:
		// TODO（hanwen）：如果（dst，a，b）有公共对齐
		// 我们仍然可以尝试fastXORBytes。目前尚不清楚这种情况发生的频率，只有在块加密本身是硬件加速的情况下才值得。
		safeXORBytes(dst, a, b, n)
	}
	return n
}

const wordSize = int(unsafe.Sizeof(uintptr(0)))
const supportsUnaligned = runtime.GOARCH == "386" || runtime.GOARCH == "ppc64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "s390x"

// fastXORBytes大量使用XOR。它只适用于
// 支持未对齐读/写的体系结构。
// n需要小于或等于a和b的长度。
func fastXORBytes(dst, a, b []byte, n int) {
	// Assert dst有足够的空间
	_ = dst[n-1]

	w := n / wordSize
	if w > 0 {
		dw := *(*[]uintptr)(unsafe.Pointer(&dst))
		aw := *(*[]uintptr)(unsafe.Pointer(&a))
		bw := *(*[]uintptr)(unsafe.Pointer(&b))
		for i := 0; i < w; i++ {
			dw[i] = aw[i] ^ bw[i]
		}
	}

	for i := (n - n%wordSize); i < n; i++ {
		dst[i] = a[i] ^ b[i]
	}
}

// n需要小于或等于a和b的长度。
func safeXORBytes(dst, a, b []byte, n int) {
	for i := 0; i < n; i++ {
		dst[i] = a[i] ^ b[i]
	}
}

// FastXORWORD XOR 4或8字节的倍数（取决于架构）
// 假设参数长度相等。
func fastXORWords(dst, a, b []byte) {
	dw := *(*[]uintptr)(unsafe.Pointer(&dst))
	aw := *(*[]uintptr)(unsafe.Pointer(&a))
	bw := *(*[]uintptr)(unsafe.Pointer(&b))
	n := len(b) / wordSize
	for i := 0; i < n; i++ {
		dw[i] = aw[i] ^ bw[i]
	}
}

// fastXORWords或4或8字节的XOR倍数（取决于体系结构。）
// 假定切片参数a和b的长度相等。
func xorWords(dst, a, b []byte) {
	if supportsUnaligned {
		fastXORWords(dst, a, b)
	} else {
		safeXORBytes(dst, a, b, len(b))
	}
}
